home *** CD-ROM | disk | FTP | other *** search
/ PC World 2006 November / PCWorld_2006-11_cd.bin / domacnost a kancelar / findgraph / fgraph.exe / {app} / UserModels / models.cpp next >
C/C++ Source or Header  |  2004-10-06  |  17KB  |  656 lines
  1. #include "stdafx.h"
  2. #include "Models.h"
  3. #include <math.h>
  4. //-------------------------------------------------------------------------------------------------
  5.  
  6. ////////////////////////////////////////////////////////////////////////////////////////////////
  7. //
  8. // Id must be <= 999
  9. /*
  10. static FuncDesc g_ListFunc[] =  // MODELS_LIST_START()
  11. {
  12. //Id, FuncName , FuncForm , FuncCalc , FuncCheck , FuncDefau ,
  13.    1, Poly_Name  , Poly_Form  , Poly_Calc  , Poly_Check  , Poly_Defau  ,
  14. //---------------------------------------------------------
  15.   -1, NULL     , NULL     , NULL     , NULL      , NULL
  16. };                                // MODELS_LIST_END()
  17. */
  18. MODELS_LIST_START()
  19. //    MODELS_LIST_ADD(1, Poly)  // use it as example
  20.     MODELS_LIST_ADD(2, S2Bind)
  21.     MODELS_LIST_ADD(3, S2Comp)
  22.     MODELS_LIST_ADD(4, E2Decay)
  23.     MODELS_LIST_ADD(5, E2Assoc)
  24.     MODELS_LIST_ADD(6, D2Biph)
  25.     MODELS_LIST_ADD(7, DAssym)
  26.     MODELS_LIST_ADD(8, L2Biph)
  27.     MODELS_LIST_ADD(9, S2Gauss)
  28.     MODELS_LIST_ADD(10, S2Loren)
  29. MODELS_LIST_END()
  30.  
  31. static int g_nFunctions = sizeof (g_ListFunc) /  sizeof (FuncDesc);
  32. ////////////////////////////////////////////////////////////////////////////////////////////////
  33.  
  34. int FittingModelsList(int nIdList, int *pnIds, int *pNum)
  35. {
  36.     int i=0;
  37.     while (g_ListFunc[i].m_nId > 0)
  38.     {
  39.         pnIds[i] = g_ListFunc[i].m_nId;
  40.         i++;
  41.     };
  42.     *pNum = i;
  43.     return  i;
  44. }
  45.  
  46.  
  47. FuncDesc *PFittingDescInId(int nId)
  48. {
  49.     int  i=0,
  50.          n = g_nFunctions;
  51.  
  52.     for (;i<g_nFunctions; i++)
  53.         if (nId  == g_ListFunc[i].m_nId)
  54.             return &g_ListFunc[i];
  55.     return NULL;
  56. }
  57.  
  58.  
  59. ////////////////////////////////////////////////////////////////////////////////////////////////
  60. //
  61. void InitParams(double *pfParams, int nParams)
  62. {
  63.     for (int i=0; i<nParams; i++) pfParams[i] = 0.;
  64. }
  65.  
  66.  
  67. int Only1Param(double *pfParams, int nParams)
  68. {
  69.     for (int i=1; i<nParams; i++) pfParams[i] = 0.;
  70.     return 1;
  71. }
  72.  
  73. int OnlyBParam(double *pfParams, int nParams)
  74. {
  75.     pfParams[0] = 0.;
  76.     for (int i=2; i<nParams; i++) pfParams[i] = 0.;
  77.     return 1;
  78. }
  79.  
  80. int Only2Param(double *pfParams, int nParams)
  81. {
  82.     for (int i=2; i<nParams; i++) pfParams[i] = 0.;
  83.     return 2;
  84. }
  85.  
  86. int Only3Param(double *pfParams, int nParams)
  87. {
  88.     for (int i=3; i<nParams; i++) pfParams[i] = 0.;
  89.     return 3;
  90. }
  91.  
  92. int OnlyACDPrm(double *pfParams, int nParams)
  93. {
  94.     pfParams[1] = 0.; // B
  95.     for (int i=4; i<nParams; i++) pfParams[i] = 0.;
  96.     return 3;
  97. }
  98.  
  99. int Only4Param(double *pfParams, int nParams)
  100. {
  101.     for (int i=4; i<nParams; i++) pfParams[i] = 0.;
  102.     return 4;
  103. }
  104.  
  105. int Only5Param(double *pfParams, int nParams)
  106. {
  107.     for (int i=5; i<nParams; i++) pfParams[i] = 0.;
  108.     return 5;
  109. }
  110. int Only6Param(double *pfParams, int nParams)
  111. {
  112.     for (int i=6; i<nParams; i++) pfParams[i] = 0.;
  113.     return 6;
  114. }
  115. int Only7Param(double *pfParams, int nParams)
  116. {
  117.     for (int i=7; i<nParams; i++) pfParams[i] = 0.;
  118.     return 7;
  119. }
  120.  
  121.  
  122. ////////////////////////////////////////////////////////////////////////////////////////////////
  123. //
  124. //------------------------------------------------------------------------------
  125. //
  126. // Fill information string with name of equation.
  127. // It is used in FindGraph <Master of approximations page 3><Functions>.
  128. //
  129. // Input:
  130. //        lpszName - buffer TCHAR
  131. //      nLen - maximum buffer length
  132. //
  133. // Output:
  134. //        lpszName - name of approximation method
  135. //
  136. // return: no
  137. //
  138. // Example:
  139. //     lstrcpyn(lpszName, "Polynomial", nLen);
  140. //
  141. void Poly_Name (LPTSTR lpszName, int nLen) {lstrcpyn(lpszName, "Polynomial", nLen);}
  142.  
  143. // Fill information string with the equation of function.
  144. // It is used in FindGraph <Master of approximations page 3><Left panel>.
  145. //
  146. // Input:
  147. //        lpszForm - buffer TCHAR
  148. //      nLen - maximum buffer length
  149. //
  150. // Output:
  151. //        lpszForm - name of approximation method
  152. //
  153. // return: no
  154. //
  155. // Important: replace parameters:
  156. //      'a'-'aa', 'b'-'bb', 'c'-'cc', 'd'-'dd', 'g'-'gg', 'h'-'hh', 'k'-'kk', 'l'-'ll', 'm'-'mm' 
  157. //
  158. // Example:
  159. //      lstrcpyn(lpszForm, "y = aa + bb*x", nLen);
  160. //
  161. void Poly_Form (LPTSTR lpszForm, int nLen) 
  162. {
  163.     lstrcpyn(lpszForm, "y = aa + bb*x + cc*x^2 + dd*x^3 + gg*x^4 + hh*x^5 + kk*x^6", nLen);
  164. }
  165.  
  166. // Prepare approximation function: x(u) = u, y(u) = f(u).
  167. // This function is called in Simplex to prepare curve fitting.
  168. //
  169. // Input:
  170. //      pfParams - array of parameters pfParams[0]=a [A_PARAM], b,c,d,g,h,k,l,m
  171. //      nParams  - number of parameters in array 
  172. //        u - floating-point value
  173. //
  174. // Output:
  175. // Values x(u) and y(u) are calculated.
  176. //        px - pointer to x value
  177. //        py - pointer to y value
  178. //
  179. // return: 1 if success, or -1 if error.
  180. //
  181. // Example: 
  182. //      *px = u;
  183. //      *py = A_PARAM + B_PARAM*u;
  184. //
  185. int  Poly_Calc (double *pfParams, int nParams, double u, double *px, double *py)
  186. {
  187.     *px = u;
  188.     *py = A_PARAM + B_PARAM*u + C_PARAM*u*u + D_PARAM*u*u*u + G_PARAM*u*u*u*u
  189.         + H_PARAM*u*u*u*u*u + K_PARAM*u*u*u*u*u*u;
  190.     return 1;
  191. }
  192.  
  193. // Check and init parameters.
  194. // This function is called in Simplex to prepare curve fitting.
  195. //
  196. // Input:
  197. //      pfParams - array of parameters pfParams[0]=a [A_PARAM], b,c,d,g,h,k,l,m
  198. //      nParams  - number of parameters in array 
  199. //
  200. // Output: 
  201. //      pfParams
  202. //
  203. // return: number of parameters used.
  204. //
  205. // Example: 
  206. //      return Only2Param(pfParams, nParams);
  207. // Tip: 
  208. //      Use functions Only1Param, ... Only9Param
  209. //
  210. int  Poly_Check(double *pfParams, int nParams)
  211. {
  212.     return Only7Param(pfParams, nParams);
  213. }
  214.  
  215. // Init parameters with default values.
  216. // It is used in FindGraph <Master of approximations page 3><Parameters>.
  217. //
  218. // Input:
  219. //      pfParams - array of parameters pfParams[0]=a [A_PARAM], b,c,d,g,h,k,l,m
  220. //      nParams  - number of parameters in array 
  221. //      px - array of values: px[0]=Min(x),  px[1]=Max(x),  px[2]=Medium(x);
  222. //      py - array of values: py[0]=Min(y),  py[1]=Max(y),  py[2]=Medium(y);
  223. //                            (x,y) points are used in curve fitting.
  224. //      bNormed  - if TRUE, parameters pfParams are normed to Min(x)-Max(x), Min(y)-Max(y);
  225. //                 see check box <Master of approximations page 3><Normalize X>.
  226. //
  227. // Output: 
  228. //      pfParams
  229. //
  230. // return: number of parameters used.
  231. //
  232. // Example: 
  233. //      A_PARAM = Y_MIN;
  234. //      B_PARAM = (Y_MAX-Y_MIN)/(X_MAX-X_MIN);
  235. //
  236. int  Poly_Defau(double *pfParams, int nParams, double *px, double *py, BOOL bNormed)
  237. {
  238.     InitParams(pfParams, nParams);
  239.     if (bNormed)
  240.     {
  241.         B_PARAM = 1;
  242.     }
  243.     else
  244.     {
  245.         A_PARAM = Y_MIN;
  246.         B_PARAM = (Y_MAX-Y_MIN)/(X_MAX-X_MIN);
  247.     }
  248.     return 7;
  249. }
  250.  
  251. //------------------------------------------------------------------------------
  252. void S2Bind_Name (LPTSTR lpszName, int nLen) {lstrcpyn(lpszName, "Two site binding", nLen);}
  253. void S2Bind_Form (LPTSTR lpszForm, int nLen) 
  254. {
  255.     lstrcpyn(lpszForm, "y = aa + bb*x/(cc+x) + dd*x/(gg+x)", nLen);
  256. }
  257. int  S2Bind_Calc (double *pfParams, int nParams, double u, double *px, double *py)
  258. {
  259.     *px = u;
  260.     double r1 = C_PARAM+u,
  261.            r2 = G_PARAM+u;
  262.     if (r1*r2 == 0) return 0;
  263.     *py = A_PARAM + B_PARAM*u/r1 + D_PARAM*u/r2;
  264.     return 1;
  265. }
  266. int  S2Bind_Check(double *pfParams, int nParams)
  267. {
  268.     return Only5Param(pfParams, nParams);
  269. }
  270. int  S2Bind_Defau(double *pfParams, int nParams, double *px, double *py, BOOL bNormed)
  271. {
  272.     InitParams(pfParams, nParams);
  273.     if (bNormed)
  274.     {
  275.         B_PARAM = D_PARAM = 0.5;
  276.         C_PARAM = 0.25;
  277.         G_PARAM = 0.75;
  278.     }
  279.     else
  280.     {
  281.         A_PARAM = Y_MIN;
  282.         B_PARAM = D_PARAM = 0.5*(Y_MAX-Y_MIN);
  283.         C_PARAM = 0.75*X_MIN+0.25*X_MAX;
  284.         G_PARAM = 0.25*X_MIN+0.75*X_MAX;
  285.     }
  286.     return 5;
  287. }
  288.  
  289. //------------------------------------------------------------------------------
  290. void S2Comp_Name (LPTSTR lpszName, int nLen) {lstrcpyn(lpszName, "Two site competition", nLen);}
  291. void S2Comp_Form (LPTSTR lpszForm, int nLen) 
  292. {
  293.     lstrcpyn(lpszForm, "y = aa + bb*cc/(1+10^(x-dd))+ bb*(1-cc)/(1+10^(x-gg))", nLen);
  294. }
  295. int  S2Comp_Calc (double *pfParams, int nParams, double u, double *px, double *py)
  296. {
  297.     *px = u;
  298.     if (C_PARAM < 0.) C_PARAM = 0.;
  299.     if (C_PARAM > 1.) C_PARAM = 1.;
  300.     double f1 = pow(10, u-D_PARAM),
  301.            f2 = pow(10, u-G_PARAM);
  302.     *py = A_PARAM + B_PARAM*C_PARAM/(1+f1) + B_PARAM*(1-C_PARAM)/(1+f2);
  303.     return 1;
  304. }
  305. int  S2Comp_Check(double *pfParams, int nParams)
  306. {
  307.     return Only5Param(pfParams, nParams);
  308. }
  309. int  S2Comp_Defau(double *pfParams, int nParams, double *px, double *py, BOOL bNormed)
  310. {
  311.     InitParams(pfParams, nParams);
  312.     if (bNormed)
  313.     {
  314.         B_PARAM = 1.0;
  315.         C_PARAM = 0.5;
  316.         D_PARAM = 0.25;
  317.         G_PARAM = 0.75;
  318.     }
  319.     else
  320.     {
  321.         A_PARAM = Y_MIN;
  322.         B_PARAM = Y_MAX-Y_MIN;
  323.         C_PARAM = 0.5;
  324.         D_PARAM = 0.75*X_MIN+0.25*X_MAX;
  325.         G_PARAM = 0.25*X_MIN+0.75*X_MAX;
  326.     }
  327.     return 5;
  328. }
  329.  
  330. //------------------------------------------------------------------------------
  331. void E2Decay_Name (LPTSTR lpszName, int nLen) {lstrcpyn(lpszName, "Two phase exp. decay", nLen);}
  332. void E2Decay_Form (LPTSTR lpszForm, int nLen) 
  333. {
  334.     lstrcpyn(lpszForm, "y = aa + bb*exp(-cc*x)+ dd*exp(-gg*x)", nLen);
  335. }
  336. int  E2Decay_Calc (double *pfParams, int nParams, double u, double *px, double *py)
  337. {
  338.     *px = u;
  339.     if (C_PARAM < 0.) C_PARAM = 0.;
  340.     if (G_PARAM < 0.) G_PARAM = 0.;
  341.     *py = A_PARAM + B_PARAM*exp(-C_PARAM*u) + D_PARAM*exp(-G_PARAM*u);
  342.     return 1;
  343. }
  344. int  E2Decay_Check(double *pfParams, int nParams)
  345. {
  346.     return Only5Param(pfParams, nParams);
  347. }
  348. int  E2Decay_Defau(double *pfParams, int nParams, double *px, double *py, BOOL bNormed)
  349. {
  350.     InitParams(pfParams, nParams);
  351.     if (bNormed)
  352.     {
  353.         B_PARAM = 
  354.         D_PARAM = 1.0;
  355.         C_PARAM = 0.3;
  356.         G_PARAM = 3.0;
  357.     }
  358.     else
  359.     {
  360.         A_PARAM = Y_MIN;
  361.         B_PARAM = 
  362.         D_PARAM = Y_MAX-Y_MIN;
  363.         C_PARAM = 0.3/(X_MAX-X_MIN);
  364.         G_PARAM = 3.0/(X_MAX-X_MIN);
  365.     }
  366.     return 5;
  367. }
  368.  
  369.  
  370. //------------------------------------------------------------------------------
  371. void E2Assoc_Name (LPTSTR lpszName, int nLen) {lstrcpyn(lpszName, "Two phase exp. association", nLen);}
  372. void E2Assoc_Form (LPTSTR lpszForm, int nLen) 
  373. {
  374.     lstrcpyn(lpszForm, "y = aa + bb*(1-exp(-cc*x))+ dd*(1-exp(-gg*x))", nLen);
  375. }
  376. int  E2Assoc_Calc (double *pfParams, int nParams, double u, double *px, double *py)
  377. {
  378.     *px = u;
  379.     if (C_PARAM < 0.) C_PARAM = 0.;
  380.     if (G_PARAM < 0.) G_PARAM = 0.;
  381.     *py = A_PARAM + B_PARAM*(1-exp(-C_PARAM*u)) + D_PARAM*(1-exp(-G_PARAM*u));
  382.     return 1;
  383. }
  384. int  E2Assoc_Check(double *pfParams, int nParams)
  385. {
  386.     return Only5Param(pfParams, nParams);
  387. }
  388. int  E2Assoc_Defau(double *pfParams, int nParams, double *px, double *py, BOOL bNormed)
  389. {
  390.     InitParams(pfParams, nParams);
  391.     if (bNormed)
  392.     {
  393.         B_PARAM = 
  394.         D_PARAM = 1.0;
  395.         C_PARAM = 0.3;
  396.         G_PARAM = 3.0;
  397.     }
  398.     else
  399.     {
  400.         A_PARAM = Y_MIN;
  401.         B_PARAM = 
  402.         D_PARAM = Y_MAX-Y_MIN;
  403.         C_PARAM = 0.3/(X_MAX-X_MIN);
  404.         G_PARAM = 3.0/(X_MAX-X_MIN);
  405.     }
  406.     return 5;
  407. }
  408.  
  409.  
  410.  
  411. //------------------------------------------------------------------------------
  412. void D2Biph_Name (LPTSTR lpszName, int nLen) {lstrcpyn(lpszName, "Dose-response biphasic", nLen);}
  413. void D2Biph_Form (LPTSTR lpszForm, int nLen) 
  414. {
  415.     lstrcpyn(lpszForm, "y = aa + bb*cc/(1+10^((x-dd)*gg))+ bb*(1-cc)/(1+10^((x-kk)*ll))", nLen);
  416. }
  417. int  D2Biph_Calc (double *pfParams, int nParams, double u, double *px, double *py)
  418. {
  419.     *px = u;
  420.     if (C_PARAM < 0.) C_PARAM = 0.;
  421.     if (C_PARAM > 1.) C_PARAM = 1.;
  422.     double f1 = pow(10, (u-D_PARAM)*G_PARAM),
  423.            f2 = pow(10, (u-K_PARAM)*L_PARAM);
  424.     *py = A_PARAM + B_PARAM*C_PARAM/(1+f1) + B_PARAM*(1-C_PARAM)/(1+f2);
  425.     return 1;
  426. }
  427. int  D2Biph_Check(double *pfParams, int nParams)
  428. {
  429.     return Only7Param(pfParams, nParams);
  430. }
  431. int  D2Biph_Defau(double *pfParams, int nParams, double *px, double *py, BOOL bNormed)
  432. {
  433.     InitParams(pfParams, nParams);
  434.     if (bNormed)
  435.     {
  436.         B_PARAM = 1.0;
  437.         C_PARAM = 0.5;
  438.         D_PARAM = 0.25;
  439.         K_PARAM = 0.75;
  440.         G_PARAM = 
  441.         L_PARAM = 0.5;
  442.     }
  443.     else
  444.     {
  445.         A_PARAM = Y_MIN;
  446.         B_PARAM = Y_MAX-Y_MIN;
  447.         C_PARAM = 0.5;
  448.         D_PARAM = 0.75*X_MIN+0.25*X_MAX;
  449.         K_PARAM = 0.25*X_MIN+0.75*X_MAX;
  450.         G_PARAM = 
  451.         L_PARAM = 0.5/(X_MAX-X_MIN);
  452.     }
  453.     return 7;
  454. }
  455.  
  456.  
  457. //------------------------------------------------------------------------------
  458. void DAssym_Name (LPTSTR lpszName, int nLen) {lstrcpyn(lpszName, "Dose-response asymmetric", nLen);}
  459. void DAssym_Form (LPTSTR lpszForm, int nLen) 
  460. {
  461.     lstrcpyn(lpszForm, "y = aa + bb/(1+10^((x-dd)*gg))^cc)", nLen);
  462. }
  463. int  DAssym_Calc (double *pfParams, int nParams, double u, double *px, double *py)
  464. {
  465.     *px = u;
  466.     if (C_PARAM < 0.) C_PARAM = 0.;
  467.     double f1 = pow(10, (u-D_PARAM)*G_PARAM),
  468.            f2 = pow(1+f1, C_PARAM);
  469.     *py = A_PARAM + B_PARAM / f2;
  470.     return 1;
  471. }
  472. int  DAssym_Check(double *pfParams, int nParams)
  473. {
  474.     return Only5Param(pfParams, nParams);
  475. }
  476. int  DAssym_Defau(double *pfParams, int nParams, double *px, double *py, BOOL bNormed)
  477. {
  478.     InitParams(pfParams, nParams);
  479.     if (bNormed)
  480.     {
  481.         B_PARAM = 1.0;
  482.         C_PARAM = 1.0;
  483.         D_PARAM = 0.0;
  484.         G_PARAM = 0.5;
  485.     }
  486.     else
  487.     {
  488.         A_PARAM = Y_MIN;
  489.         B_PARAM = Y_MAX-Y_MIN;
  490.         C_PARAM = 1.0;
  491.         D_PARAM = X_MIN;
  492.         G_PARAM = 0.5/(X_MAX-X_MIN);
  493.     }
  494.     return 5;
  495. }
  496.  
  497.  
  498.  
  499. //------------------------------------------------------------------------------
  500. void L2Biph_Name (LPTSTR lpszName, int nLen) {lstrcpyn(lpszName, "Logistic biphasic", nLen);}
  501. void L2Biph_Form (LPTSTR lpszForm, int nLen) 
  502. {
  503.     lstrcpyn(lpszForm, "y = aa + bb*cc/(1+exp(-(x-dd)*gg))+ bb*(1-cc)/(1+exp(-(x-dd)*hh))", nLen);
  504. }
  505. int  L2Biph_Calc (double *pfParams, int nParams, double u, double *px, double *py)
  506. {
  507.     *px = u;
  508.     if (C_PARAM < 0.) C_PARAM = 0.;
  509.     if (C_PARAM > 1.) C_PARAM = 1.;
  510.     double f1 = 1.+exp(-(u-D_PARAM)*G_PARAM),
  511.            f2 = 1.+exp(-(u-D_PARAM)*H_PARAM);
  512.     *py = A_PARAM + B_PARAM*C_PARAM/(1+f1) + B_PARAM*(1-C_PARAM)/(1+f2);
  513.     return 1;
  514. }
  515. int  L2Biph_Check(double *pfParams, int nParams)
  516. {
  517.     return Only6Param(pfParams, nParams);
  518. }
  519. int  L2Biph_Defau(double *pfParams, int nParams, double *px, double *py, BOOL bNormed)
  520. {
  521.     InitParams(pfParams, nParams);
  522.     if (bNormed)
  523.     {
  524.         B_PARAM = 1.0;
  525.         C_PARAM = 0.5;
  526.         D_PARAM = 0.0;
  527.         G_PARAM = 0.25;
  528.         H_PARAM = 0.75;
  529.     }
  530.     else
  531.     {
  532.         A_PARAM = Y_MIN;
  533.         B_PARAM = Y_MAX-Y_MIN;
  534.         C_PARAM = 0.5;
  535.         D_PARAM = X_MIN;
  536.         G_PARAM = 0.25/(X_MAX-X_MIN);
  537.         H_PARAM = 0.75/(X_MAX-X_MIN);
  538.     }
  539.     return 6;
  540. }
  541.  
  542.  
  543.  
  544.  
  545. //------------------------------------------------------------------------------
  546. void S2Gauss_Name (LPTSTR lpszName, int nLen) {lstrcpyn(lpszName, "Sum of two Gaussians", nLen);}
  547. void S2Gauss_Form (LPTSTR lpszForm, int nLen) 
  548. {
  549.     lstrcpyn(lpszForm, "y = aa + bb*exp(-0.5*((x-cc)/dd)^2)+ gg*exp(-0.5*((x-hh)/kk)^2)", nLen);
  550. }
  551. int  S2Gauss_Calc (double *pfParams, int nParams, double u, double *px, double *py)
  552. {
  553.     *px = u;
  554.     double r ,
  555.            s1 = 0.,
  556.            s2 = 0.;
  557.     if (D_PARAM != 0)
  558.     {
  559.         r = (u-C_PARAM)/D_PARAM;
  560.         s1= exp(-0.5*r*r);
  561.     }
  562.     if (K_PARAM != 0)
  563.     {
  564.         r = (u-H_PARAM)/K_PARAM;
  565.         s2= exp(-0.5*r*r);
  566.     }
  567.         
  568.     *py = A_PARAM + B_PARAM*s1 + G_PARAM*s2;
  569.     return 1;
  570. }
  571. int  S2Gauss_Check(double *pfParams, int nParams)
  572. {
  573.     return Only7Param(pfParams, nParams);
  574. }
  575. int  S2Gauss_Defau(double *pfParams, int nParams, double *px, double *py, BOOL bNormed)
  576. {
  577.     InitParams(pfParams, nParams);
  578.     if (bNormed)
  579.     {
  580.         B_PARAM = 
  581.         G_PARAM = 0.5;
  582.         D_PARAM = 
  583.         K_PARAM = 0.5;
  584.         C_PARAM = 0.25;
  585.         H_PARAM = 0.75;
  586.     }
  587.     else
  588.     {
  589.         A_PARAM = Y_MIN;
  590.         B_PARAM = 
  591.         G_PARAM = (Y_MAX-Y_MIN)*0.5;
  592.         D_PARAM = 
  593.         K_PARAM = (X_MAX-X_MIN)*0.5;
  594.         C_PARAM = 0.75*X_MIN+0.25*X_MAX;
  595.         H_PARAM = 0.25*X_MIN+0.75*X_MAX;
  596.     }
  597.     return 7;
  598. }
  599.  
  600.  
  601. //------------------------------------------------------------------------------
  602. void S2Loren_Name (LPTSTR lpszName, int nLen) {lstrcpyn(lpszName, "Sum of two Lorentizian", nLen);}
  603. void S2Loren_Form (LPTSTR lpszForm, int nLen) 
  604. {
  605.     lstrcpyn(lpszForm, "y = aa + bb/(1+((x-cc)/dd)^2)+ gg/(1+((x-hh)/kk)^2)", nLen);
  606. }
  607. int  S2Loren_Calc (double *pfParams, int nParams, double u, double *px, double *py)
  608. {
  609.     *px = u;
  610.     double r ,
  611.            s1 = 0.,
  612.            s2 = 0.;
  613.     if (D_PARAM != 0)
  614.     {
  615.         r = (u-C_PARAM)/D_PARAM;
  616.         s1= 1/(1+r*r);
  617.     }
  618.     if (K_PARAM != 0)
  619.     {
  620.         r = (u-H_PARAM)/K_PARAM;
  621.         s2= 1/(1+r*r);
  622.     }
  623.         
  624.     *py = A_PARAM + B_PARAM*s1 + G_PARAM*s2;
  625.     return 1;
  626. }
  627. int  S2Loren_Check(double *pfParams, int nParams)
  628. {
  629.     return Only7Param(pfParams, nParams);
  630. }
  631. int  S2Loren_Defau(double *pfParams, int nParams, double *px, double *py, BOOL bNormed)
  632. {
  633.     InitParams(pfParams, nParams);
  634.     if (bNormed)
  635.     {
  636.         B_PARAM = 
  637.         G_PARAM = 0.5;
  638.         D_PARAM = 
  639.         K_PARAM = 0.5;
  640.         C_PARAM = 0.25;
  641.         H_PARAM = 0.75;
  642.     }
  643.     else
  644.     {
  645.         A_PARAM = Y_MIN;
  646.         B_PARAM = 
  647.         G_PARAM = (Y_MAX-Y_MIN)*0.5;
  648.         D_PARAM = 
  649.         K_PARAM = (X_MAX-X_MIN)*0.5;
  650.         C_PARAM = 0.75*X_MIN+0.25*X_MAX;
  651.         H_PARAM = 0.25*X_MIN+0.75*X_MAX;
  652.     }
  653.     return 7;
  654. }
  655.  
  656.